package com.fdb.efp.nls.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fdb.basic.framework.core.base.FrameworkService;
import com.fdb.basic.framework.core.constant.MonAlrmLvlEnums.MonAlrmLvlEnum;
import com.fdb.basic.framework.core.constant.StdZbHandleEnums.StdZbHandleEnum;
import com.fdb.basic.framework.core.exception.ESBException;
import com.fdb.basic.framework.core.util.*;
import com.fdb.efp.nls.service.facade.CtrLoanContService;
import com.fdb.efp.nls.service.vo.CtrLoanContVO;
import com.fdb.efp.cus.service.facade.CusIndivService;
import com.fdb.efp.nls.common.ImageBizConstant;
import com.fdb.efp.nls.common.UploadFileConstant;
import com.fdb.efp.nls.service.vo.ImageBizDetailVO;
import com.fdb.efp.nls.service.vo.ImageBizInfoVO;
import com.fdb.efp.nls.service.vo.LogErrorInfoVO;
import com.fdb.efp.nls.common.bo.UpLoadFileVO;
import com.fdb.efp.nls.service.util.OpfFileUtil;
import com.fdb.efp.nls.service.facade.*;
import com.fdb.efp.esb.common.constant.ElectronicSignatureConstant;
import com.fdb.efp.esb.common.constant.ElectronicSignatureEnums;
import com.fdb.efp.esb.service.bo.req.dzqz.ReqElectronicSignature3001Bean;
import com.fdb.efp.esb.service.bo.req.dzqz.ReqElectronicSignature3201Bean;
import com.fdb.efp.esb.service.bo.req.dzqz.ReqElectronicSignature3203Bean;
import com.fdb.efp.esb.service.bo.req.dzqz.ReqElectronicSignatureDL01Bean;
import com.fdb.efp.esb.service.bo.req.dzqz.info.*;
import com.fdb.efp.nls.service.facade.LoanPolicyService;
import com.fdb.efp.nls.service.facade.NlsApplyInfoService;
import com.fdb.efp.nls.service.vo.NlsApplyInfoVO;
import com.jcraft.jsch.ChannelSftp;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 
 * 交互文件服务-影像文件解析
 * 
 * @author ludayong
 * @since 2019年1月2日 下午7:05:26
 * @version 1.0
 */
@Service("imageFileAnalysisService")
public class ImageFileAnalysisServiceImpl implements ImageFileAnalysisService, FrameworkService {

	private static Logger logger = LoggerFactory.getLogger(ImageFileAnalysisServiceImpl.class);

	@Value("${gzcb.authaddr}")
	private String authaddr;// 授权地址

	@Value("${sign.contr_nm}")
	private String contrNm;// 合同名称

	@Value("${sign.sign_kwd1}")
	private String signKwd1;// 签署关键字

	@Value("${sign.signonpgcnt}")
	private String signonpgcnt;// 签名域页数

	@Value("${sign.signposnlbx}")
	private String signposnlbx;// 签名域的左下角x轴坐标值

	@Value("${sign.signposnlby}")
	private String signposnlby;// 签名域的左下角y轴坐标值

	@Value("${sign.signposnrux}")
	private String signposnrux;// 签名域的右上角x轴坐标值

	@Value("${sign.signposnruy}")
	private String signposnruy;// 签名域的右上角y轴坐标值

	@Value("${sign.xofstcoordposn}")
	private String xofstcoordposn;// X轴偏移坐标

	@Value("${sign.yofstcoordposn}")
	private String yofstcoordposn;// Y轴偏移坐标

	@Value("${sign.signimgwdth}")
	private String signimgwdth;// 签章图片宽度

	@Value("${sign.signimghght}")
	private String signimghght;// 签章图片高度

	@Value("${opf.remoteFile}")
	private String remoteFile;// 开放平台上传文件目录

	@Value("${opf.scrtFlag}")
	private String scrtFlag;// 开放平台上传文件目录标识

	@Value("${analysis.imageFilePath}")
	private String imageFilePath;// 影像文件解析路径

	@Value("${analysis.archImageFilePath}")
	private String archImageFilePath;// 影像文件归档路径

	@Value("${analysis.downNum}")
	private int downNum;// 影像文件下载最多个数

	@Value("${file.remoteImagesDownPath}")
	private String remoteImagesDownPath;// 前置文件服务器：影像文件下载地址

	@Value("${file.remoteImagesBakPath}")
	private String remoteImagesBakPath;// 前置文件服务器：影像文件备份地址

	@Value("${ftp.host}")
	private String host;// 前置文件服务器IP地址

	@Value("${ftp.username}")
	private String username;// 前置文件服务器用户名

	@Value("${ftp.pwd}")
	private String pwd;// 前置文件服务器登录密码

	@Value("${ftp.port}")
	private int port;// 前置文件服务器端口号

	@Value("${up_imagesys_flag}")
	private String upImagesysFlag;// 是否上传影像系统

	@Autowired
	@Qualifier("imageBizInfoService")
	private ImageBizInfoService imageBizInfoService;// 影像业务信息

	@Autowired
	@Qualifier("imageBizDetailService")
	private ImageBizDetailService imageBizDetailService;// 影像业务文件

	@Autowired
	@Qualifier("imageQueueTaskService")
	private ImageQueueTaskService imageQueueTaskService;// 影像任务队列

	@Autowired
	@Qualifier("loanPolicyService")
	private LoanPolicyService loanPolicyService;// 保单信息

	@Autowired
	@Qualifier("electronicSignPolyService")
	private ElectronicSignPolyService electronicSignPolyService;// 电子签章聚合服务

	@Autowired
	@Qualifier("cusIndivService")
	private CusIndivService cusIndivService;// 客户中心

	@Autowired
	@Qualifier("cfcaSignInfoService")
	private CfcaSignInfoService cfcaSignInfoService;// CFCA签署信息

	@Autowired
	@Qualifier("nlsApplyInfoService")
	private NlsApplyInfoService nlsApplyInfoService;// 网贷申请基本信息

	@Autowired
	@Qualifier("ctrLoanContService")
	private CtrLoanContService ctrLoanContService;// 贷款合同

	@Autowired
	@Qualifier("upLoadFileService")
	private UpLoadFileService upLoadFileService;// 上传影像平台

	@Autowired
	@Qualifier("logErrorInfoService")
	private LogErrorInfoService logErrorInfoService;// 异常信息表

	/**
	 * 
	 * 交互文件服务-影像文件解析
	 * 
	 * @param paramMap
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月2日 下午7:06:52
	 * @version 1.0
	 */
	@Override
	public synchronized boolean analysisImageFile() throws Exception {
		boolean fileDownRes = downloadFile();// 前置文件服务器下载文件
		long startTime = System.currentTimeMillis();
		logger.info("交互文件服务-影像文件解析：[" + DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始！");
		boolean result = false;
		// 1、解压影像文件
		File files = new File(imageFilePath);// 解析文件
		if (fileDownRes && files.exists()) {// 文件存在
			File[] imageFiles = files.listFiles();
			if (imageFiles.length > 0) {
				for (File imageFile : imageFiles) {
					if (imageFile.getName().endsWith(ZipUtil.EXT)) {// 单笔业务影像文件
						try {
							// 1、解压影像文件
							boolean unZipResult = ZipUtil.unZipAll(new File(imageFile.getAbsolutePath()),
									new File(imageFile.getAbsolutePath().replace(ZipUtil.EXT, "")), true);
							if (unZipResult) {
								try {
									result = this.handleImageFile(imageFile.getAbsolutePath(),
											imageFile.getName().replace(ZipUtil.EXT, ""));
								} catch (Exception e) {
									result = false;
									logger.error("交互文件服务-影像文件解析出现异常，异常信息" + e.getMessage());
									e.printStackTrace();
								}
							}
						} catch (Exception e) {
							result = false;
							logger.error("交互文件服务-影像文件解压出现异常，异常信息" + e.getMessage());
							e.printStackTrace();
						}
					}
				}
			}
		}
		long endTime = System.currentTimeMillis();
		logger.info("交互文件服务-影像文件解析：[" + DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束！");
		logger.info("交互文件服务-影像文件解析，耗时：[" + (endTime - startTime) / 1000.0 + "]秒！");
		return result;
	}

	/**
	 * 
	 * 1、交互文件服务-影像文件解析（身份证正面、身份证反面、征信授权书、合同、活体照）校验影像文件个数<br/>
	 * 2、合同签章<br/>
	 * 3、所有上传影像文件到影像系统 <br/>
	 * 4、签章合同回传合作方<br/>
	 * 
	 * @param filePath
	 * @param fileName
	 * @return boolean
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月2日 下午7:06:52
	 * @version 1.0
	 */
	private boolean handleImageFile(String filePath, String fileName) throws Exception {
		String analysisPath = filePath.replace(ZipUtil.EXT, "");// 解析文件目录
		String moveToPath = analysisPath.replace(imageFilePath, archImageFilePath);

		boolean signFlag = false;// 是否需要签章
		boolean reslut = false;// 文件解析处理结果

		boolean loanProtocolIsExit = false;// 合同文件是否存在
		boolean signReslut = false;// 电子签章处理结果
		boolean upOPFReslut = false;// 合同上传互开服务器处理结果
		boolean upImageSysReslut = false;// 上传影像文件到影像系统处理结果
		boolean renameReslut = false;// 前置文件服务器移动文件结果
		boolean addBizInfoRes = false;// 新增/更新影像业务信息数据结果
		boolean addBizDetaiRes = false;// 新增/更新影像业务文件数据结果

		// 1、交互文件服务-影像文件解析（身份证正面、身份证反面、征信授权书、合同、活体照）校验影像文件个数
		String applySeq = fileName;// 申请流水号
		
		/** 
		 * 【变更内容】
		 * 		新增客户证件号码、客户名称、产品名称
		 * 【变更原因】
		 * 		1、新增客户证件号码，为了前端页面能查看通过API上传的相关影像信息
		 * 		2、新增的客户名称、产品名称，是影像平台为了做页面搜索条件
		 *  @date 2019/04/03 
		 *  @author qiuyf 
		 */
		UpLoadFileVO vo = new UpLoadFileVO();
		//流水号
		vo.setApplySeq(applySeq);
		
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setApplySeq(applySeq);// 申请流水号
		logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

		Map<String, Object> param = new HashMap<String, Object>();
		// 网贷申请基本信息
		NlsApplyInfoVO inNlsApplyInfoVO = new NlsApplyInfoVO();
		inNlsApplyInfoVO.setApplySeq(applySeq);
		NlsApplyInfoVO queryNlsApplyInfoVO = nlsApplyInfoService.queryByPk(inNlsApplyInfoVO);// 查询网贷申请基本信息

		try {
			Objects.requireNonNull(queryNlsApplyInfoVO);// 网贷申请基本信息不为空
			param.put("nlsApplyInfoVO", queryNlsApplyInfoVO);
			/** @date 2019/03/29 @author qiuyf*/
			//客户证件号码
			vo.setCertCode(queryNlsApplyInfoVO.getCertCode());
			//客户名称
			vo.setCusName(queryNlsApplyInfoVO.getCusName());
			//产品名称
			vo.setPrdName(queryNlsApplyInfoVO.getPrdName());
		} catch (Exception e) {
			e.printStackTrace();
			String remark = "网贷申请基本信息为空！";
			logErrorInfoVo.setTableName("nls_apply_info");// 表名
			logErrorInfoVo.setErrorMsg(remark);// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			return false;
		}

		// 查询贷款合同信息
		CtrLoanContVO inCtrLoanContVo = new CtrLoanContVO();
		inCtrLoanContVo.setContNo(queryNlsApplyInfoVO.getApplySeq());// 业务流水号
		CtrLoanContVO queryCtrLoanContVo = ctrLoanContService.queryByCondition(inCtrLoanContVo);
		try {
			if (!StringUtil.isNullorBank(queryNlsApplyInfoVO.getDnSts())) {// 放款状态不为空时
				Objects.requireNonNull(queryCtrLoanContVo);// 合同信息不为空
				param.put("ctrLoanContVo", queryCtrLoanContVo);// 贷款合同信息
			}
		} catch (Exception e) {
			e.printStackTrace();
			String remark = "贷款合同信息为空！";
			logger.error(remark + e.getMessage());
			logErrorInfoVo.setTableName("ctr_loan_cont");// 表名
			logErrorInfoVo.setErrorMsg(remark);// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			return false;
		}

		ImageBizInfoVO imageBizInfoVO = new ImageBizInfoVO();// 影像业务信息
		imageBizInfoVO.setApplySeq(applySeq);// 申请流水号
		imageBizInfoVO.setPrdId(queryNlsApplyInfoVO.getPrdId());// 产品id
		imageBizInfoVO.setPrdCode(queryNlsApplyInfoVO.getPrdCode());// 产品代码
		imageBizInfoVO.setPrdName(queryNlsApplyInfoVO.getPrdName());// 产品名称
		imageBizInfoVO.setCusId(queryNlsApplyInfoVO.getCusId());// 客户号
		imageBizInfoVO.setCusName(queryNlsApplyInfoVO.getCusName());// 客户名称
		imageBizInfoVO.setSoltImageAccept(ImageBizConstant.YesNoEnum.YES.VALUE);// 影像文件接收
		// imageBizInfo.setSoltImageCfca(ImageBizConstant.YesNoEnum.NO.VALUE);// 影像文件加签
		// imageBizInfo.setSoltImageThird1(ImageBizConstant.YesNoEnum.NO.VALUE);//传送给影像系统
		// imageBizInfo.setSoltImageThird2(ImageBizConstant.YesNoEnum.NO.VALUE);//传送给业务联合方
		imageBizInfoVO.setCreateTime(currentTime);// 创建时间
		imageBizInfoVO.setCreateDate(DateTool.getCurrentDate());// 创建日期
		imageBizInfoVO.setLastModifyTime(currentTime);// 最近修改时间

		List<ImageBizDetailVO> imageBizDetailList = new ArrayList<ImageBizDetailVO>();// 影像业务文件
		List<UpLoadFileVO> upLoadFilelList = new ArrayList<UpLoadFileVO>();// 上传影像平台

		File files = new File(analysisPath);
		File[] imgFiles = files.listFiles();
		for (File imgFile : imgFiles) {
			String conFilePath = imgFile.getParent();// 文件路径
			String imageReaFilePath = imgFile.getAbsolutePath();// 文件路径
			imageReaFilePath = imageReaFilePath.replace(imageFilePath, archImageFilePath);
			String imageFileName = imgFile.getName();// 文件名

			String imgFileName = imageFileName.replace(applySeq + "_", "");// 去除申请流水号文件名
			String imageId = imgFileName.indexOf(".") >= 0 ? imgFileName.substring(0, imgFileName.indexOf(".")) : "";// 影像标识

			ImageBizDetailVO imageBizDetailVO = new ImageBizDetailVO();// 影像业务文件
			imageBizDetailVO.setApplySeq(applySeq);// 申请流水号
			imageBizDetailVO.setImageId(UUIDUtil.getUUID());// 影像标识

			UpLoadFileVO upLoadFileVO = new UpLoadFileVO();// 上传影像平台信息
			upLoadFileVO.setApplySeq(applySeq);// 申请流水号
			upLoadFileVO.setFilePath(imageReaFilePath);// 上传文件路径
			String currentDate = new SimpleDateFormat("yyyyMMdd").format(new Date());// 流水号生成时间 yyyymmdd
			if (!StringUtil.isNullorBank(queryNlsApplyInfoVO.getApplyDate())) {
				currentDate = queryNlsApplyInfoVO.getApplyDate().replaceAll("-", "");
			}
			upLoadFileVO.setStartDate(currentDate);// 流水号生成时间

			boolean addFlag = true;
			switch (imageId) {
			case ImageBizConstant.FILE_SIGN_CERT_F:
				imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A01);// 影像类型
				imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_CERT_F_DESC);// 文件描述
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A01);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_CERT_B:
				imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A02);// 影像类型
				imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_CERT_B_DESC);// 文件描述
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A02);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_FACE:
				imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A03);// 影像类型
				imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_FACE_DESC);// 文件描述
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A03);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_CREDIT_AUTH:
				imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A04);// 影像类型
				imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_CREDIT_AUTH_DESC);// 文件描述
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A04);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL:
				imageBizDetailVO.setImageType(ImageBizConstant.IMAGE_TYPE_A05);// 影像类型
				imageBizDetailVO.setFileDesc(ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL_DESC);// 文件描述
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A05);// 影像类型
				break;
			default:
				addFlag = false;
				boolean removeFileRes = ZipUtil.deleteFile(imgFile.getAbsolutePath());
				logger.info("清理未识别的影像文件，目标路径：" + imgFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
				break;
			}
			imageBizDetailVO.setFileName(imageFileName);// 文件名
			imageBizDetailVO.setFilePath(imageReaFilePath);// 文件路径
			// imageBizDetail.setBizStage(bizStage);//所属业务阶段
			imageBizDetailVO.setCreateTime(currentTime);// 创建时间
			imageBizDetailVO.setLastModifyTime(currentTime);// 最近修改时间

			if (addFlag && !ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL.equals(imageId)) {// 防止非联合放款成功，有合同文件出现新增记录情况
				imageBizDetailList.add(imageBizDetailVO);
			}

			upLoadFileVO.setCreateTime(currentTime);// 创建时间
			upLoadFileVO.setLastModifyTime(currentTime);// 最近修改时间
			if (addFlag && !ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL.equals(imageId)) {// 防止非联合放款成功，有合同文件出现新增记录情况
				upLoadFilelList.add(upLoadFileVO);
			}
			String signFlagStr = this.getSignFlag(queryNlsApplyInfoVO.getDnSts(),
					queryCtrLoanContVo == null ? "" : queryCtrLoanContVo.getContState(), imageId);

			if (!StringUtil.isNullorBank(imageId) && imageId.equals(ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL)) {
				loanProtocolIsExit = true;// 合同文件存在

				if (!imageFileName.endsWith(ImageBizConstant.LOAN_PROTOCOL_SUFFIX)) {
					String remark = "合同文件类型异常，请上传PDF格式合同文件！";
					logErrorInfoVo.setErrorMsg(remark);// 错误信息
					logErrorInfoVo.setRemark(remark);// 备注
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					throw new Exception(remark);
				}

				if ("1".equals(signFlagStr) || "-02".equals(signFlagStr)) {
					imageBizDetailList.add(imageBizDetailVO);// 合同文件
					upLoadFilelList.add(upLoadFileVO);// 上传影像信息
				}

				// reslut = "-01";// 非联合放款成功，但有合同文件
				// reslut = "-02";// 贷款合同状态非待签订
//				if ("-01".equals(signFlagStr)) {
//					boolean removeFileRes = ZipUtil.deleteFile(imgFile.getAbsolutePath());
//					logger.info("非联合放款成功，但有合同文件，清理合同文件，目标路径：" + imgFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
//					continue;
//				} else 
				if ("-02".equals(signFlagStr)) {
					// 不签署该合同，直接上送影像平台
					String remark = "贷款合同状态[" + queryCtrLoanContVo.getContState() + "]非待签订！";
					logErrorInfoVo.setTableName("ctr_loan_cont");// 表名
					logErrorInfoVo.setErrorMsg(remark);// 错误信息
					logErrorInfoVo.setRemark(remark);// 备注
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.WARNING.getEnname());// 错误级别
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					continue;
				}

				signFlag = true;
				// 3、合同签章
				param.put("applySeq", applySeq);
				param.put("tranCode", ElectronicSignatureConstant.TRAN_CODE_3203);
				param.put("opnFlg", ImageBizConstant.YesNoEnum.NO.VALUE);

				param.put("imageFilePath", imgFile.getAbsolutePath());// 合同文件路径
				param.put("conFilePath", conFilePath + File.separator);// 签章合同存放路径
				param.put("imageFileName", imageFileName);// 文件名

				try {
					param = this.initSignInfo(param);// 电子签章-签章信息初始化处理
				} catch (Exception e) {
					logErrorInfoVo.setTableName("ctr_loan_cont");// 表名
					logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
					logErrorInfoVo.setRemark(e.getMessage());// 备注
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.WARNING.getEnname());// 错误级别
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					throw new Exception(e.getMessage(), e);
				}
				try {
					signReslut = electronicSignPolyService.handleElectronicSignPoly(param);// 电子签章-处理
					if (signReslut) {
						imageBizInfoVO.setSoltImageCfca(ImageBizConstant.YesNoEnum.YES.VALUE);// 影像文件加签
					} else {
						imageBizInfoVO.setSoltImageCfca(ImageBizConstant.YesNoEnum.NO.VALUE);// 影像文件加签
					}
				} catch (ESBException e) {
					imageBizInfoVO.setSoltImageCfca(ImageBizConstant.YesNoEnum.NO.VALUE);// 影像文件加签
					throw new Exception(e.getMessage(), e);
				}

				if (signReslut) {// 电子签章处理结果
					String remotePath = remoteFile + imgFile.getName();
					if (!StringUtil.isNullorBank(queryNlsApplyInfoVO.getApplyDate())) {
						remotePath = remoteFile + queryNlsApplyInfoVO.getApplyDate().replaceAll("-", "") + File.separator
								+ imgFile.getName();
					}

					try {
						if (!ElectronicSignatureConstant.CONT_STATUS_200.equals(queryCtrLoanContVo.getContState())) {
							upOPFReslut = OpfFileUtil.uploadFile(imgFile.getAbsolutePath(), remotePath, scrtFlag);
							logger.info("合同上传开放平台，目标路径：" + remotePath + "，结果[" + upOPFReslut + "]");
						} else {
							upOPFReslut = true;
						}
						if (!upOPFReslut) {
							imageBizInfoVO.setSoltImageThird2(ImageBizConstant.YesNoEnum.NO.VALUE);// 传送给业务联合方

							logErrorInfoVo.setErrorMsg("合同上传开放平台出错！");// 错误信息
							logErrorInfoVo.setRemark("合同上传开放平台出错！");// 备注
							logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
							logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
							logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
						} else {
							imageBizInfoVO.setSoltImageThird2(ImageBizConstant.YesNoEnum.YES.VALUE);// 传送给业务联合方
							if (!ElectronicSignatureConstant.CONT_STATUS_200.equals(queryCtrLoanContVo.getContState())) {
								// 更新合同数据（已签订）
								inCtrLoanContVo.setContState(ElectronicSignatureConstant.CONT_STATUS_200);// 设置合同状态
								inCtrLoanContVo.setSignDate(DateTool.getCurrentDate());// 签订日期
								logger.info("电子签章操作更新合同信息：" + JSONObject.toJSONString(inCtrLoanContVo.getContNo()));
								int num = ctrLoanContService.updateByPk(inCtrLoanContVo);
								logger.info("电子签章操作更新合同信息数目：" + JSONObject.toJSONString(num));
							}
						}
					} catch (Exception e) {
						imageBizInfoVO.setSoltImageThird2(ImageBizConstant.YesNoEnum.NO.VALUE);// 传送给业务联合方

						logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
						logErrorInfoVo.setRemark("合同上传开放平台出错！");// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
						throw new Exception(e.getMessage(), e);
					}
				}
			}
		}

		if (ElectronicSignatureConstant.DN_STS_1.equals(queryNlsApplyInfoVO.getDnSts()) && !loanProtocolIsExit) {
			String remark = "当前申请信息放款状态为联合放款成功[" + queryNlsApplyInfoVO.getDnSts() + "]，影像文件缺少合同文件！";
			logErrorInfoVo.setErrorMsg(remark);// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			throw new Exception(remark);
		}

		if (signFlag) {// 合同签章
			if ("1".equals(upImagesysFlag) && upOPFReslut) {// 合同上传互开服务器处理结果
				try {
					upImageSysReslut = uploadFileToImageSys(vo, analysisPath, upLoadFilelList);// 上传影像文件到影像系统处理结果
					if (!upImageSysReslut) {
						imageBizInfoVO.setSoltImageThird1(ImageBizConstant.YesNoEnum.NO.VALUE);// 传送给影像系统

						logErrorInfoVo.setErrorMsg("上传影像文件到影像系统出错！");// 错误信息
						logErrorInfoVo.setRemark("上传影像文件到影像系统出错！");// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					} else {
						imageBizInfoVO.setSoltImageThird1(ImageBizConstant.YesNoEnum.YES.VALUE);// 传送给影像系统
					}
				} catch (Exception e) {
					imageBizInfoVO.setSoltImageThird1(ImageBizConstant.YesNoEnum.NO.VALUE);// 传送给影像系统

					logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
					logErrorInfoVo.setRemark("上传影像文件到影像系统出错！");// 备注
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					throw new Exception(e.getMessage(), e);
				}
				logger.info("上传影像文件到影像系统处理结果：[" + upImageSysReslut + "]");
			}
		} else {
			if ("1".equals(upImagesysFlag)) {
				try {
					upImageSysReslut = uploadFileToImageSys(vo, analysisPath, upLoadFilelList);// 上传影像文件到影像系统处理结果
					if (!upImageSysReslut) {
						logErrorInfoVo.setErrorMsg("上传影像文件到影像系统出错！");// 错误信息
						logErrorInfoVo.setRemark("上传影像文件到影像系统出错！");// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					}
				} catch (Exception e) {
					logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
					logErrorInfoVo.setRemark("上传影像文件到影像系统出错！");// 备注
					logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
					logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
					logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					throw new Exception(e.getMessage(), e);
				}
				logger.info("上传影像文件到影像系统处理结果：[" + upImageSysReslut + "]");
			}
		}
		if ("1".equals(upImagesysFlag) && upImageSysReslut || !"1".equals(upImagesysFlag)) {// 上传影像文件到影像系统处理结果
			renameReslut = renameFile(remoteImagesDownPath, fileName + ZipUtil.EXT, remoteImagesBakPath);
			logger.info("前置文件服务器移动文件结果，目标路径：" + remoteImagesBakPath + fileName + ZipUtil.EXT + "，结果[" + renameReslut + "]");
			if (!renameReslut) {
				String remark = "前置文件服务器移动文件出现异常";
				logErrorInfoVo.setErrorMsg(remark);// 错误信息
				logErrorInfoVo.setRemark(remark);// 备注
				logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
				logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
				logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			}
		}

		if (renameReslut) {// 前置文件服务器移动文件结果
			addBizInfoRes = addImageBizInfo(imageBizInfoVO);// 新增影像业务信息
			addBizDetaiRes = addImageBizDetail(imageBizDetailList);// 新增影像业务文件信息
		}
		if (addBizInfoRes && addBizDetaiRes) {// 影像文件解析后处理
			reslut = analysisAfterHandleFile(analysisPath, moveToPath, filePath);
		}
		return reslut;
	}

	/**
	 * 新增影像业务信息
	 * 
	 * @param imageBizInfoVO
	 * 
	 * @return
	 * @author ludayong
	 * @since 2019年1月17日 下午8:40:42
	 * @version 1.0
	 */
	private boolean addImageBizInfo(ImageBizInfoVO imageBizInfoVO) {
		int bizInfoNum = 0;// 新增/更新影像业务信息数据条数
		boolean reslut = false;
		logger.info("当前新增/更新影像业务信息数据为:" + JSONObject.toJSONString(imageBizInfoVO));
		ImageBizInfoVO queryImageBizInfoVO = imageBizInfoService.queryByPk(imageBizInfoVO);
		if (queryImageBizInfoVO != null) {
			bizInfoNum = imageBizInfoService.updateByPk(imageBizInfoVO);
		} else {
			bizInfoNum = imageBizInfoService.insertImageBizInfo(imageBizInfoVO);
		}
		logger.info("当前新增/更新影像业务信息数据条数为:" + bizInfoNum);

		if (bizInfoNum > 0) {
			reslut = true;
		}
		return reslut;
	}

	/**
	 * 新增影像业务文件信息
	 * 
	 * @param imageBizDetailList
	 * 
	 * @return
	 * @author ludayong
	 * @since 2019年1月17日 下午8:40:42
	 * @version 1.0
	 */
	private boolean addImageBizDetail(List<ImageBizDetailVO> imageBizDetailList) {
		int bizDetaiNum = 0;// 新增/更新影像业务文件数据条数
		boolean reslut = false;
		logger.info("当前新增/更新影像业务文件数据为:" + JSONObject.toJSONString(imageBizDetailList));
		// 文件移动后新增/更新影像业务文件数据
		if (imageBizDetailList != null && !imageBizDetailList.isEmpty()) {
			for (ImageBizDetailVO imageBizDetailVO1 : imageBizDetailList) {
				List<ImageBizDetailVO> queryImageBizDetailList = imageBizDetailService.queryByApplySeqAndImageType(imageBizDetailVO1);
				if (queryImageBizDetailList != null && !queryImageBizDetailList.isEmpty()) {
					bizDetaiNum += imageBizDetailService.updateByApplySeqAndImageType(imageBizDetailVO1);
				} else {
					bizDetaiNum += imageBizDetailService.insertImageBizDetail(imageBizDetailVO1);
				}
			}
		}
		logger.info("当前新增/更新影像业务文件数据条数为:" + bizDetaiNum);
		if (bizDetaiNum > 0) {
			reslut = true;
		}
		return reslut;
	}

	/**
	 * 影像文件解析后文件处理
	 * 
	 * @param analysisPath
	 *            解析路径
	 * @param moveToPath
	 *            归档路径
	 * @param filePath
	 *            删除zip路径
	 * @return
	 * @author ludayong
	 * @since 2019年1月17日 下午8:40:42
	 * @version 1.0
	 */
	private boolean analysisAfterHandleFile(String analysisPath, String moveToPath, String filePath) {
		// 移动文件
		// boolean moveDirRes = ZipUtil.moveDirectory(analysisPath, moveToPath);
		// logger.info("移动目录，目标路径：" + moveToPath + "，结果[" + moveDirRes + "]");
		File srcDir = new File(analysisPath);
		if (srcDir.exists()) {// 文件存在
			File[] sourceFiles = srcDir.listFiles();
			if (sourceFiles.length > 0) {
				for (File sourceFile : sourceFiles) {
					if (sourceFile.isFile()) {
						File destFile = new File(moveToPath + File.separator + sourceFile.getName());
						if (destFile.exists()) {
							boolean removeFileRes = ZipUtil.deleteFile(destFile.getAbsolutePath());
							logger.info("目标文件存在，删除文件，目标路径：" + destFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
							boolean moveFileRes = ZipUtil.moveFile(sourceFile.getAbsolutePath(), destFile.getParent());
							logger.debug("源路径：" + sourceFile.getAbsolutePath() + "，目标路径：" + destFile.getParent());
							logger.info("移动文件，目标路径：" + destFile.getAbsolutePath() + "，结果[" + moveFileRes + "]");
						} else {
							boolean moveFileRes = ZipUtil.moveFile(sourceFile.getAbsolutePath(), destFile.getParent());
							logger.debug("源路径：" + sourceFile.getAbsolutePath() + "，目标路径：" + destFile.getParent());
							logger.info("移动文件，目标路径：" + destFile.getAbsolutePath() + "，结果[" + moveFileRes + "]");
						}
					}
				}
			}
		}

		File finallySrcPath = new File(analysisPath);
		File[] finallySrcFiles = finallySrcPath.listFiles();
		if (finallySrcFiles.length == 0) {
			boolean removeResult = ZipUtil.deleteFolder(analysisPath);// 删除空目录
			logger.info("删除空目录，目标路径:" + analysisPath + "结果[" + removeResult + "]");
		}
		boolean removeFileRes = ZipUtil.deleteFile(filePath);
		logger.info("删除文件，目标路径：" + filePath + "，结果[" + removeFileRes + "]");
		return removeFileRes;
	}

	/**
	 * 
	 * 电子签章-签章信息初始化处理<br>
	 * 
	 * @param param
	 * @return
	 * @date:2018年12月18日 下午3:35:05
	 * @author:ludayong
	 */
	private Map<String, Object> initSignInfo(Map<String, Object> param) throws ESBException, Exception {
		String reqBodyBean = JSONObject.toJSONString(param);
		String tranCode = (String) param.get("tranCode");// 交易代码（接口代码）
		String opnFlg = (String) param.get("opnFlg");// 开户标识

		ReqElectronicSignature3001Bean req3001Bean = null;// 个人开户3001请求信息
		ReqElectronicSignature3201Bean req3201Bean = null;// 创建合同3201请求信息
		ReqElectronicSignature3203Bean req3203Bean = null;// 上传合同3203请求信息
		ReqElectronicSignatureDL01Bean reqCADL01Bean = null;// 合同下载DL01请求信息

		// 1.转换请求bean
		req3001Bean = JSON.toJavaObject(JSONObject.parseObject(reqBodyBean), ReqElectronicSignature3001Bean.class); // 个人开户3001请求信息
		req3201Bean = JSON.toJavaObject(JSONObject.parseObject(reqBodyBean), ReqElectronicSignature3201Bean.class); // 创建合同3201请求信息
		req3203Bean = JSON.toJavaObject(JSONObject.parseObject(reqBodyBean), ReqElectronicSignature3203Bean.class); // 上传合同3203请求信息
		reqCADL01Bean = JSON.toJavaObject(JSONObject.parseObject(reqBodyBean), ReqElectronicSignatureDL01Bean.class); // 合同下载DL01请求信息

		NlsApplyInfoVO nlsApplyInfoVO = (NlsApplyInfoVO) param.get("nlsApplyInfoVO");// 网贷申请基本信息

		if (ElectronicSignatureEnums.YesNoEnum.YES.VALUE.equals(opnFlg)) {// 需要开户
			ElectronicSignature3001ReqPersonInfo person = new ElectronicSignature3001ReqPersonInfo();
			person.setUsrNm(nlsApplyInfoVO.getCusName());// 客户名称
			person.setCertTp(nlsApplyInfoVO.getCertType());
			person.setCertNo(nlsApplyInfoVO.getCertCode());// 安心签会校验身份证格式
			// person.setUserEmail("");// 邮箱与手机号不能同时为空；安心签会校验邮箱格式
			person.setMblNo(nlsApplyInfoVO.getMobile());// 邮箱与手机号不能同时为空；安心签会校验手机号格式
			person.setCtcAddr(nlsApplyInfoVO.getIndivRsdAddr());// 联系地址
			// 客户平台与安心签协议中，明确的认证方式，例如：线下人工审核；公安部数据联网核查；绑定银行卡实名认证；其他（说明方式）
			person.setAuthMode(ElectronicSignatureConstant.AUTHENTICATION_MODE_02);

			req3001Bean.setPerson(person);
			// 0：发送；1：不发送；默认为0，建议选择发送
			req3001Bean.setSendPswdMsgFlg(ElectronicSignatureEnums.SendEnum.NotSend.VALUE);
			// 0：不校验；1：校验；默认为0
			req3001Bean.setVrfyBankCardInfFlg(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);
		}

		if (ElectronicSignatureConstant.TRAN_CODE_3203.equals(tranCode)) {
			ElectronicSignature3203BaseInfo uploadContract = new ElectronicSignature3203BaseInfo();

			uploadContract.setSignFlg(ElectronicSignatureConstant.IS_SIGN_1);// 签署标志
			uploadContract.setContrTp(ElectronicSignatureConstant.CONTRACT_TYPE_CODE_JK);// 合同类型
			uploadContract.setContrNm(contrNm);// 合同名称

			ElectronicSignature3203SignKeyWord signKeyword = new ElectronicSignature3203SignKeyWord();
			signKeyword.setSignKwd(signKwd1); // 关键字
			signKeyword.setXOfstCoordPosn(xofstcoordposn); // X轴偏移坐标
			signKeyword.setYOfstCoordPosn(yofstcoordposn); // Y轴偏移坐标
			signKeyword.setSignImgWdth(signimgwdth); // 签章图片宽度
			signKeyword.setSignImgHght(signimghght); // 签章图片高度

			uploadContract.setSignKeyword(signKeyword);

			// **************************************************//
			List<ElectronicSignature3203SignPosnInfArry> signPosnInfArry = new ArrayList<ElectronicSignature3203SignPosnInfArry>();// 签名域签章信息
			ElectronicSignature3203SignPosnInfArry signLocation1 = new ElectronicSignature3203SignPosnInfArry();
			signLocation1.setSignOnPgCnt("1"); // 签名域页数
			signLocation1.setSignPosnLBX("85"); // 签名域的左下角X轴坐标值
			signLocation1.setSignPosnLBY("550"); // 签名域的左下角Y轴坐标值
			signLocation1.setSignPosnRUX("140"); // 签名域的右上角X轴坐标值
			signLocation1.setSignPosnRUY("575"); // 签名域的右上角Y轴坐标值

			signPosnInfArry.add(signLocation1);

			uploadContract.setSignPosnInfArry(signPosnInfArry);

			List<ElectronicSignature3203SignInfo> signInfos = new ArrayList<ElectronicSignature3203SignInfo>();// 签署信息
			ElectronicSignature3203SignInfo signInfo1 = new ElectronicSignature3203SignInfo();

			signInfo1.setUsrID(UUIDUtil.getUUID());// 用户ID
			signInfo1.setAuthTm(TimeUtil.getTimeStampByPattern("yyyyMMddHHmmss"));// 授权时间
			signInfo1.setAuthAddr(authaddr);// 授权地点
			signInfo1.setPrjNo(UUIDUtil.getUUID());// 项目编号
			signInfos.add(signInfo1);

			uploadContract.setSignBscInfArry(signInfos);
			// **************************************************//

			req3203Bean.setUploadContract(uploadContract);
		} else if (ElectronicSignatureConstant.TRAN_CODE_3201.equals(tranCode)) {
			ElectronicSignature3201BaseInfo createContract = new ElectronicSignature3201BaseInfo();// 请求包信息

			createContract.setContrTplId(UUIDUtil.getUUID());// 待定
			createContract.setSignFlg(ElectronicSignatureConstant.IS_SIGN_1);// 签署标识
			createContract.setContrNm(contrNm);// 合同名称

			List<ElectronicSignature3201SignInfo> signInfos = new ArrayList<ElectronicSignature3201SignInfo>();// 签署信息
			ElectronicSignature3201SignInfo signInfo1 = new ElectronicSignature3201SignInfo();

			signInfo1.setAuthTm(DateTool.getCurrentDateTimess());// 授权时间
			signInfo1.setAuthAddr(authaddr);// 授权地点
			signInfo1.setSignPosVal("待定");
			signInfo1.setPrjNo(UUIDUtil.getUUID());// 项目编号
			// 0：不代签；1：代签；默认为0。不代签的用户，可自行登录安心签使用自己的数字证书完成协议签署。
			signInfo1.setAgncSignFlg(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);
			// 0：不抄送；1：抄送；默认为0如果抄送则AgncSignFlg项无效
			signInfo1.setCopyFlg(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);

			signInfos.add(signInfo1);
			createContract.setSignBscInfArry(signInfos);

			Map<String, String> flPosInf = new HashMap<String, String>();// 文本域信息
			flPosInf.put("text1", "");
			flPosInf.put("text2", "");

			createContract.setFlPosInf(flPosInf);
			// 0：不保存；1：保存；默认为0
			createContract.setSaveFlPosInfFlg(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 文本域信息保存标志

			req3201Bean.setCreateContract(createContract);
		}

		param.put("req3001Bean", req3001Bean);
		param.put("req3201Bean", req3201Bean);
		param.put("req3203Bean", req3203Bean);
		param.put("reqCADL01Bean", reqCADL01Bean);
		return param;
	}

	/**
	 * 从前置文件服务器下载文件
	 * 
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月15日 上午8:54:23
	 * @version 1.0
	 */
	private boolean downloadFile() throws Exception {
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		long startTime = System.currentTimeMillis();
		logger.info("前置文件服务器获取文件：[" + DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始！");
		// 连接前置文件服务器
		SFTPUtil sftpUtil = null;
		boolean fileDownRes = false;// 下载文件是否成功
		int downTotal = 0;
		List<String> states = new ArrayList<String>();
		states.add(StdZbHandleEnum.PENDING.getEnname());// 未处理
		states.add(StdZbHandleEnum.HANGING.getEnname());// 处理中

		try {
			// 从前置文件服务器下载文件到本地
			sftpUtil = new SFTPUtil(username, pwd, host, port);
			// 检测解析目录是否有需要解析的文件存在
			Vector<ChannelSftp.LsEntry> files = sftpUtil.ls(remoteImagesDownPath);
			Objects.requireNonNull(files);// 文件不允许为空

			long handTime = System.currentTimeMillis() - 5 * 60 * 1000;
			for (ChannelSftp.LsEntry file : files) {
				String fileName = file.getFilename();// 下载文件名
				long fileMTime = file.getAttrs().getMTime() * 1000L;
				logger.info("处理时间[" + handTime + "]，文件最后修改时间[" + fileMTime + "]");
				if (".".equals(fileName) || "..".equals(fileName) || ZipUtil.EXT.equals(fileName) || !fileName.endsWith(ZipUtil.EXT)) {
					continue;
				} else if (isMatchesCn(fileName)) {
					int num = logErrorInfoService.countByApplySeqAndStates(fileName, states);// 错误信息
					if (num < 3) {// 当前申请流水记录累计出现三次异常且未处理，不获取当前申请流水的合同文件
						LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
						logErrorInfoVo.setApplySeq(fileName);// 申请流水号
						logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
						logErrorInfoVo.setCreateTime(currentTime);// 创建时间
						logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
						String remark = "影像文件命名不规范（包含中文），请检查！";
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoVo.setErrorMsg(remark);// 错误信息
						logErrorInfoVo.setRemark(remark);// 备注
						logErrorInfoVo.setErrorType(MonAlrmLvlEnum.WARNING.getEnname());// 错误级别
						logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
						logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
					}
					continue;
				} else if (downTotal >= downNum) {
					break;// 每次下载downNum个文件
				} else {// 前置文件服务器下载文件，文件在5分钟以前上传的
					String applySeq = fileName.replace(ZipUtil.EXT, "");
					try {
						LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
						logErrorInfoVo.setApplySeq(applySeq);// 申请流水号
						logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
						// int num = logErrorInfoService.countByApplySeq(logErrorInfoVo);// 错误信息
						int num = logErrorInfoService.countByApplySeqAndStates(applySeq, states);// 错误信息
						if (num >= 3) {// 当前申请流水记录累计出现三次异常且未处理，不获取当前申请流水的合同文件
							// 删除文件夹
							File removeDirfile = new File(imageFilePath + applySeq);
							if (removeDirfile.exists()) {
								boolean removeDirRes = ZipUtil.deleteDirectory(imageFilePath + applySeq);
								logger.info("当前申请流水记录累计出现三次异常且未处理，清理文件夹，目标路径：" + imageFilePath + applySeq + "，结果[" + removeDirRes + "]");
							}
							File removeFilefile = new File(imageFilePath + fileName);
							if (removeFilefile.exists()) {
								// 删除文件
								boolean removeFileRes = ZipUtil.deleteFile(imageFilePath + fileName);
								logger.info("当前申请流水记录累计出现三次异常且未处理，清理文件，目标路径：" + imageFilePath + fileName + "，结果[" + removeFileRes + "]");
							}
							continue;// 不获取当前申请流水的合同文件
						}
						boolean singleFileDownRes = sftpUtil.downFile(sftpUtil, remoteImagesDownPath, file.getFilename(), imageFilePath,
								file.getFilename(), false);
						logger.info("前置文件服务器下载文件：" + remoteImagesDownPath + file.getFilename() + "，结果[" + singleFileDownRes + "]");
						if (singleFileDownRes) {
							downTotal++;// 下载文件数
						}
					} catch (Exception e) {
						e.printStackTrace();
						String remark = "前置文件服务器下载文件出现异常，异常信息：" + e.getMessage();
						logger.error(remark);
						// 记录异常信息
						recordLogErrorInfo(applySeq, remark, "", MonAlrmLvlEnum.SERIOUS.getEnname());
					}
				}
			}
			if (downTotal > 0) {// 下载文件数大于0，则解析
				fileDownRes = true;
			}
			logger.info("本次前置文件服务器下载文件数目：[" + downTotal + "]");
		} catch (Exception e) {
			e.printStackTrace();
			String remark = "前置文件服务器下载文件出现异常，异常信息：" + e.getMessage();
			logger.error(remark);
			// 记录异常信息
			recordLogErrorInfo("", remark, "", MonAlrmLvlEnum.SERIOUS.getEnname());
		} finally {
			if (sftpUtil != null) {
				sftpUtil.closeSFTP();
			}
		}
		long endTime = System.currentTimeMillis();
		logger.info("前置文件服务器获取文件：[" + DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束！");
		logger.info("前置文件服务器获取文件：，耗时：[" + (endTime - startTime) / 1000.0 + "]秒！");
		return fileDownRes;
	}

	/**
	 * 前置文件服务器移动文件
	 * 
	 * @param filePath
	 * @param fileName
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月15日 上午9:23:42
	 * @version 1.0
	 */
	private boolean renameFile(String oldPath, String fileName, String newPath) {
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setApplySeq(UUIDUtil.getUUID());// 申请流水号
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

		SFTPUtil sftpUtil = null;
		boolean renameRes = false;
		try {
			// 连接前置文件服务器
			sftpUtil = new SFTPUtil(username, pwd, host, port);
			// 从前置文件服务器移动目录
			renameRes = sftpUtil.renameFile(oldPath, fileName, newPath, true, true);
		} catch (Exception e) {
			String remark = "前置文件服务器移动文件出现异常！";
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoVo.setTableName("nls_apply_info");// 表名
			logErrorInfoVo.setErrorMsg(e.getMessage());// 错误信息
			logErrorInfoVo.setRemark(remark);// 备注
			logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
			logger.error(remark + e.getMessage());
			e.printStackTrace();
		}
		return renameRes;
	}

	/**
	 * 
	 * 上传文件至影像平台
	 * 
	 * @param vo
	 * @return
	 * @author ludayong
	 * @since 2019年1月18日 上午9:42:35
	 * @version 1.0
	 */
	public boolean uploadFileToImageSys(UpLoadFileVO vo, String filePath, List<UpLoadFileVO> upLoadFilelList) throws Exception {
		boolean result = false;
		boolean upImageSysReslut = false;// 上传影像文件到影像系统处理结果
		if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
			if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
				String ret = UploadFileConstant.uploadFile(vo, filePath);// 上传影像平台
				String[] rets = ret.split("<<::>>");
				for (UpLoadFileVO upLoadFileVo : upLoadFilelList) {
					if (rets.length > 2) {// 失败
						upLoadFileVo.setState(rets[0]);// 状态
						upLoadFileVo.setBatch(rets[1]);// 返回批次号
						upLoadFileVo.setStateNum(rets[2]);// 失败状态码

						String remark = "影像文件上传影像平台出错，错误信息：";
						throw new Exception(remark + ret);
					} else {
						upLoadFileVo.setState(rets[0]);// 状态
						upLoadFileVo.setBatch(rets[1]);// 返回批次号
						upImageSysReslut = true;// 上传影像文件到影像系统处理结果
					}
				}
			}
		}

		int upLoadFileNum = 0;// 新增/更新上传影像平台信息数据条数
		if (upImageSysReslut) {// 上传影像文件到影像系统处理结果
			logger.info("当前新增/更新上传影像平台信息数据为:" + JSONObject.toJSONString(upLoadFilelList));
			// 文件移动后新增/更新影像业务文件数据
			if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
				for (UpLoadFileVO upLoadFileVo : upLoadFilelList) {
					UpLoadFileVO queryUpLoadFileVO = upLoadFileService.queryUploadFileByApplySeqAndImageType(upLoadFileVo);
					if (Objects.nonNull(queryUpLoadFileVO) && !StringUtil.isNullorBank(queryUpLoadFileVO.getApplySeq())) {
						upLoadFileNum += upLoadFileService.updateUpLoadFile(upLoadFileVo);
					} else {
						upLoadFileNum += upLoadFileService.insertUpLoadFile(upLoadFileVo);
					}
				}
			}
			logger.info("当前新增/更新上传影像平台信息数据条数为:" + upLoadFileNum);
		}
		if (upLoadFileNum > 0) {
			result = true;
		}
		return result;
	}

	/**
	 * 是否需要签章
	 * 
	 * 0 放款失败 LOAN_STATUS 放款状态</br>
	 * 1 联合放款成功 LOAN_STATUS 放款状态</br>
	 * 2 马上全额放款 LOAN_STATUS 放款状态 </br>
	 * 3待放款 LOAN_STATUS 放款状态</br>
	 * 
	 * 100 未生效 STD_ZB_CONT_STATUS 合同状态</br>
	 * 101 待签订 STD_ZB_CONT_STATUS 合同状态</br>
	 * 200 生效 STD_ZB_CONT_STATUS 合同状态 </br>
	 * 300 注销 STD_ZB_CONT_STATUS 合同状态</br>
	 * 500 冻结 STD_ZB_CONT_STATUS 合同状态 </br>
	 * 800 已出账 STD_ZB_CONT_STATUS 合同状态 </br>
	 * 999 核销 STD_ZB_CONT_STATUS 合同状态</br>
	 * 
	 * @param dnSts
	 * @param conState
	 * @param imageId
	 * @return
	 * @author ludayong
	 * @since 2019年1月25日 上午8:33:55
	 * @version 1.0
	 */
	private String getSignFlag(String dnSts, String conState, String imageId) {
		String reslut = "1";
		// 1 联合放款成功 LOAN_STATUS 放款状态 1
//		if (!ElectronicSignatureConstant.DN_STS_1.equals(dnSts)) {
//			reslut = "-01";// 非联合放款成功，但有合同文件
//			return reslut;
//		}

		// 借款借据协议加上200生效状态，防止签章后续环节出错，当前申请不能往下走
		if (!(ElectronicSignatureConstant.CONT_STATUS_101.equals(conState)
				|| ElectronicSignatureConstant.CONT_STATUS_200.equals(conState))) {
			reslut = "-02";// 贷款合同状态非待签订
			return reslut;
		}
		return reslut;
	}

	/**
	 * 
	 * @param regex
	 *            中文正则表达式
	 * @param str
	 * @return
	 */
	private boolean isMatchesCn(String str) {
		if (null == str)
			return false;
		Pattern p = Pattern.compile("[\\u4e00-\\u9fa5]");
		Matcher m = p.matcher(str);
		if (m.find()) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 记录异常信息
	 * 
	 * @param applySeq
	 * @param remark
	 * @param tableName
	 * @param errorType
	 * @return
	 * @throws Exception
	 * @author ludayong
	 * @since 2019年1月15日 上午9:23:42
	 * @version 1.0
	 */
	private void recordLogErrorInfo(String applySeq, String remark, String tableName, String errorType) {
		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		// 错误信息
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
		logErrorInfoVo.setApplySeq(applySeq);
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
		logErrorInfoVo.setTableName(tableName);// 表名
		logErrorInfoVo.setErrorMsg(remark);// 错误信息
		logErrorInfoVo.setRemark(remark);// 备注
		logErrorInfoVo.setErrorType(errorType);// 错误级别
		logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
	}
}
